#ifndef COLLISIONS_H
#   define COLLISIONS_H


#include "projectiles.h"
#include "def_etat_bataille.h"
#include "base_donnees.h"
#include "carte_zone.h"



/**
 * \fn char voir_si_intersection(const unsigned int x_min_a, const unsigned int y_min_a,
                                 const unsigned int taille_x_a, const unsigned int taille_y_a,
                                 const unsigned int x_min_b, const unsigned int y_min_b,
                                 const unsigned int taille_x_b, const unsigned int taille_y_b)
 * \brief Dit si deux zones retangulaires donnees s'intersectent ou non
 *
 * \param[in] x_min_a Coordonnee horizontale du coin superieur gauche du premier rectangle
 * \param[in] y_min_a Coordonnee verticale du coin superieur gauche du premier rectangle
 * \param[in] taille_x_a Dimension horizontale, en nombre de cases, du premier rectangle
 * \param[in] taille_y_a Dimension verticale, en nombre de cases, du premier rectangle
 * \param[in] x_min_b Coordonnee horizontale du coin superieur gauche du deuxieme rectangle
 * \param[in] y_min_b Coordonnee verticale du coin superieur gauche du deuxieme rectangle
 * \param[in] taille_x_b Dimension horizontale, en nombre de cases, du deuxieme rectangle
 * \param[in] taille_y_b Dimension verticale, en nombre de cases, du deuxieme rectangle
 * \return VRAI en cas d'intersection, FAUX sinon
 */
char voir_si_intersection(const unsigned int x_min_a, const unsigned int y_min_a,
                          const unsigned int taille_x_a, const unsigned int taille_y_a,
                          const unsigned int x_min_b, const unsigned int y_min_b,
                          const unsigned int taille_x_b, const unsigned int taille_y_b);



/**
 * \fn void gerer_apparition_projectile(struct carte_zone* carte,
                                               struct etat_bataille* bataille,
                                               const char type_attaque,
                                               const struct base_donnees* donnees)
 * \brief Prend le dernier projectile qui a ete ajoute a la liste des
 *        projectiles et entreprend diverses actions en fonction de la
 *        disponibilite de l'espace d'apparition de ce projectile
 *
 * \param[in,out] carte L'adresse de la carte de la zone actuelle
 * \param[in,out] bataille Adresse de l'etat de la bataille
 * \param[in] type_attaque Le type de l'attaque : CONTACT ou DISTANCE
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 *
 * Les regles suivies par cette fonction sont les suivantes :\n
 * On parcours la zone occupee par le projectile suivant des lignes successives
 * perpendiculaires a sa trajectoire, en s'eloignant de plus de plus du tireur.
 * Si, par exemple, on rencontre pour la premiere fois un element de decor dans
 * la 3eme ligne, alors seul le decor se trouvant sur cette ligne sera
 * endommage, et seuls les adversaires se trouvant dans l'union des deux
 * premieres lignes seront blesses. Ceci permet d'eviter que l'on ne puisse
 * blesser quelqu'un a travers un mur, par exemple.
 */
void gerer_apparition_projectile(struct carte_zone* carte,
                                 struct etat_bataille* bataille,
                                 const char type_attaque,
                                 const struct base_donnees* donnees);



/**
 * \fn char voir_si_deplacement_possible(const char direction, unsigned int x,
                                         unsigned int y,
                                         const struct carte_zone* carte, const unsigned char taille,
                                         const struct etat_bataille* bataille, const char volant,
                                         const struct base_donnees* donnees)
 * \brief Dit si un deplacement est possible ou non
 *
 * \param[in] direction La direction du deplacement souhaite
 * \param[in,out] x Coordonnee horizontale de l'element
 * \param[in,out] y Coordonnee verticale de l'element
 * \param[in] carte L'adresse de la carte de la zone actuelle
 * \param[in] taille La taille de l'element concerne
 * \param[in] bataille L'adresse de l'etat de la bataille
 * \param[in] volant VRAI si l'element vole, FAUX sinon
 * \param[in] donnees L'adresse d'une base_donnees correctement remplie
 * \return VRAI si le deplacement est possible, FAUX sinon.
 *         FAUX egalement si la direction est NEUTRE.
 *
 * \warning x et y font reference au coin superieur gauche de l'element.
 *          Pour le joueur, qui se repere par le centre, il faut appeler
 *          la fonction en faisant x + DECALAGE_X_J et y + DECALAGE_Y_J
 *
 * Cette fonction verifie la disponibilite de l'emplacement destine a etre
 * occupe et part du principe que l'emplacement actuellement occupe par
 * l'element lui meme est libre.\n
 * Notez que la fonction renvoie FAUX si la
 * direction passee en parametre est NEUTRE.\n
 * Rappels : ce qui vole peut acceder au relief negatif. Les projectiles volent.
 */
char voir_si_deplacement_possible(const char direction, unsigned int x,
                                  unsigned int y,
                                  const struct carte_zone* carte, const unsigned char taille,
                                  const struct etat_bataille* bataille, const char volant,
                                  const struct base_donnees* donnees);




/**
 * \fn char rechercher_adversaires_dans_zone(struct etat_bataille* bataille,
                                             const struct projectile* p_proj,
                                             const unsigned int x_min_zone,
                                             const unsigned int y_min_zone,
                                             const unsigned char taille_x_zone,
                                             const unsigned char taille_y_zone,
                                             const struct base_donnees* donnees)
 * \brief Permet a un projectile donne de blesser tous ses adversaires se
 *        trouvant dans une zone donnee
 *
 * \param[in,out] bataille L'adresse de l'etat de la bataille
 * \param[in] p_proj L'adresse du projectile concerne
 * \param[in] x_min_zone Coordonnee horizontale du coin superieur gauche de la zone
 * \param[in] y_min_zone Coordonnee verticale du coin superieur gauche de la zone
 * \param[in] taille_x_zone Nombre de cases de large de la zone
 * \param[in] taille_y_zone Nombre de cases de haut de la zone
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \return VRAI si au moins un adversaire a ete touche, FAUX sinon
 *
 * \warning Cette fonction supprime les ennemis morts, mais ne touche pas au
 *          projectile. Pour savoir si le projectile doit etre supprime ou non,
 *          recuperer la valeur de retour de cette fonction et
 *          agissez en consequence.
 */
char rechercher_adversaires_dans_zone(struct etat_bataille* bataille,
                                      const struct projectile* p_proj,
                                      const unsigned int x_min_zone,
                                      const unsigned int y_min_zone,
                                      const unsigned char taille_x_zone,
                                      const unsigned char taille_y_zone,
                                      const struct base_donnees* donnees);




#endif /* COLLISIONS_H */
